// var common = require("./public.js");
const config = require('./config.js')
const app = getApp()
module.exports = {
    regionId: '173',
    HttpUrl: 'https://api.feiyanghy.com',
    // HttpUrl: 'http://47.103.92.96:80',
    // HttpUrl: 'http://apitest.feiyang.life',
    // payHttpUrl: "https://www.feiyangwang.xin",
    payHttpUrl: 'https://order.feiyanghy.com',
    // payHttpUrl: 'http://47.103.92.96:80',

    filter_method(text, badword) {
        //获取文本输入框中的内容
        var value = text;
        var res = '';
        //遍历敏感词数组
        for (var i = 0; i < badword.length; i++) {
            //全局替换
            var reg = new RegExp(badword[i], "g");
            //判断内容中是否包括敏感词		
            if (value.indexOf(badword[i]) > -1) {
                // 将敏感词替换为 **
                res = value.replace(reg, "**");
                value = res;
            }
        }
        return value;
    },

    filter_methods(text, badword) {
        //获取文本输入框中的内容
        var value = text;
        var res = '';
        let falg = false;
        //遍历敏感词数组
        for (let i = 0; i < badword.length; i++) {
            //全局替换
            var reg = new RegExp(badword[i], "g");
            //判断内容中是否包括敏感词	
            if (value.indexOf(badword[i]) > -1) {
                // 将敏感词替换为 **
                falg = true;
            }
        }
        return falg;
    },
    /**
     * 显示弹框
     * @param {string} title 标题
     * @param {string} content 内容
     * @param {function} callback 回调函数，参数为点击成功返回true，点击取消返回false
     * @param {string} confirmText 确认按钮文字，默认为确认
     * @param {string} cancelText 取消按钮文字，默认为取消
     */
    showAlertView(title, content, callback, confirmText = '确认', cancelText = '取消') {
        wx.showModal({
            title,
            content,
            cancelColor: '#ccc',
            cancelText,
            confirmColor: '#e70012',
            confirmText,
            showCancel: true,
            success: (result) => {
                if (result.confirm) {
                    callback(true)
                } else {
                    callback(false)
                }
            },
            fail: (result) => { }
        })
    },
    // 封装的get请求，请求体格式为字符串拼接
    get(url, data = {}, success, loadfinish) {
        this.wxRequest(url, 'GET', data, 'application/x-www-form-urlencoded', success, loadfinish)
    },
    // 封装的post请求，请求体格式为字符串拼接
    post(url, data = {}, success, loadfinish) {
        this.wxRequest(url, 'POST', data, 'application/x-www-form-urlencoded', success, loadfinish)
    },
    // 封装的post请求，请求体格式为json格式
    postJson(url, data = {}, success, loadfinish) {
        this.wxRequest(url, 'POST', data, 'application/json', success, loadfinish)
    },
    // 封装的post请求，请求体格式为json格式
    postJsonPay(url, data = {}, success, loadfinish) {
        this.wxRequestaPay(url, 'POST', data, 'application/json', success, loadfinish)
    },
    // 封装的get请求，请求体格式为json格式
    getJson(url, data = {}, success, loadfinish) {
        this.wxRequest(url, 'GET', data, 'application/json', success, loadfinish)
    },
    wxRequestaPay(url, method, data = {}, contentType, callback, loadfinish = () => { }) {
        wx.request({
            url: this.payHttpUrl + url,
            method,
            data,
            timeout: 60000,
            header: {
                'content-type': contentType
            },
            success: (res) => {
                if (!res || res.statusCode != 200) {
                    that.showToast('您的网络开小差了，请稍后再试 - ' + res.statusCode)
                } else {
                    // http响应码为200
                    if (res.data.msg == '登录已超时，请重新登录' || res.data.msg == 'token为空,请登录') { //重新登录
                        wx.clearStorage({
                            success: function () {
                                that.showLoginPage('登录已超时，请重新登录')
                            }
                        })
                    } else if (res.msg == '请先实名认证') {
                        that.toRealName(false)
                    } else {
                        callback(res.data)
                    }
                }

                finish()
            },
            fail: function (err) {
                finish()
                that.showToast('您的网络开小差了，请稍后再试')
            }
        })
    },
    /**
     * 封装微信提供的网络请求接口，本方法为私有方法，外部使用请使用上面提供的get、post封装
     * @param {string} url 请求路径
     * @param {string} method 请求方法
     * @param {object} data 请求参数
     * @param {string} contentType 请求类型
     * @param {function} callback 请求成功（httpstatue为200）的回调
     * @param {function} loadfinish 请求结束的回调（成功和失败都会回调）
     * @discussion 由于部分接口在请求失败(如没有收藏返回的是非200)的时候不需要提示，这个接口里面没有做统一的异常处理
     */
    wxRequest(url, method, data = {}, contentType, callback, loadfinish = () => { }) {
        wx.request({
            url: this.HttpUrl + url,
            method,
            data,
            timeout: 60000,
            header: {
                'content-type': contentType
            },
            success: (response) => {
                if (response && response.statusCode !== 200) {
                    // this.showToast('您的网络开小差了，请稍后再试 - ' + response.statusCode)
                    loadfinish()
                    return
                }
                let responseType = 0 // 正常数据
                if (response) {
                    // 下面的登录过期，未实名的处理方式并不好，接口设计不合理  response.data.msg == 'token为空,请登录'
                    if (response.data.msg == '用户登陆已过期') { //重新登录
                        wx.removeStorageSync('user')
                        // let pages = getCurrentPages();
                        // let prevpage = pages[pages.length - 2];
                        // console.log(prevpage,"prevpage")
                        this.showLoginPage('您的登录已过期，请重新登录吧~')
                        responseType = 1
                    } else if (response.data.msg == '用户还没实名认证，请实名后在购买' || response.data.msg == '用户未实名' || response.data.msg == '未实名') {
                        this.toRealName()
                    } else {
                        callback(response.data)
                    }
                } else {
                    // 没有获得到响应，提示异常
                    this.showToast('您的网络开小差了，请稍后再试')
                }
                // 在处理完数据后，调用加载完成回调
                loadfinish(responseType)
            },
            fail: (res) => {
                loadfinish()
                this.showToast('您的网络开小差了，请稍后再试')
            }
        })
    },
    /**
     * 封装的微信支付
     * @param {String} url 请求路径
     * @param {Object} param 请求参数
     * @param {Function} callback 请求成功回调
     * @param {Function} finish 请求结束回调，成功或失败都会回调
     */
    wxPayRequest(url, param, callback, finish = function () { }) {
        const that = this
        wx.request({
            url: this.payHttpUrl + url,
            method: 'POST',
            data: param,
            timeout: 10000,
            header: {
                'content-type': 'application/x-www-form-urlencoded',
            },
            success(res) {
                if (!res || res.statusCode != 200) {
                    that.showToast('您的网络开小差了，请稍后再试 - ' + res.statusCode)
                } else {
                    // http响应码为200
                    if (res.data.msg == '登录已超时，请重新登录' || res.data.msg == 'token为空,请登录') { //重新登录
                        wx.clearStorage({
                            success: function () {
                                that.showLoginPage('登录已超时，请重新登录')
                            }
                        })
                    } else if (res.msg == '请先实名认证') {
                        that.toRealName(false)
                    } else {
                        callback(res.data)
                    }
                }

                finish()
            },
            fail: function (err) {
                finish()
                that.showToast('您的网络开小差了，请稍后再试')
            }
        });
    },
    /**
     * 防重复点击方法
     * @param {function} func 需要实现的函数
     * @param {number} marginTime 防重复点击的时间
     */
    throttleFunc(func, marginTime) {
        if (marginTime == undefined || marginTime == null) {
            marginTime = 1500
        }
        let lastTime = null

        return function () {
            // console.log(marginTime, "点击事件5555")

            let currentTime = +new Date()
            if (currentTime - lastTime > marginTime || !lastTime) {
                func.apply(this, arguments)

                lastTime = currentTime
            }
        }
    },
    /**
     * 登录函数
     * @param {string} back 登录成功后的返回url，默认为null，返回到当前页面
     */
    loginFunc(back = null, validateCode,) {
        const that = this
        console.log(back, "backbackbackback")
        return new Promise((resolve, reject) => {
            wx.login({
                success: function (loginRes) {
                    if (loginRes && loginRes.code && loginRes.code != '') {
                        const tempJson = {
                            code: loginRes.code,
                            validateCode: validateCode //验证码
                        }
                        that.getJson('/user/wxxcx/login', tempJson, function (res) {
                            // that.getJson('/user/wxxcx/loginUseValidate ', tempJson, function (res) {
                            if (res.status == '400' || res.status == '401') { // 没有手机号，但是有unionId
                                console.log("77567",res)
                                that.showToast(res.msg)
                                if (res.msg == '验证失败') {
                                    console.log("bil")
                                    wx.removeStorageSync('user')
                                    that.showLoginPage(null, back)
                                    return
                                }
                                app.globalData.unionId = res.data.unionId
                                app.globalData.openid = res.data.openid
                                // 新用户，有unionId,跳转手机授权页面
                                let backUrl = back //从哪个页面没有登录的
                                if (!backUrl) {
                                    backUrl = that.getCurrentPageUrlWithArgs()
                                }
                                // 重定向页面，返回链接包含页面参数
                                wx.redirectTo({
                                    url: '/pages/ZBAuthorize/index?backUrl=' + encodeURIComponent(backUrl),
                                })
                            } else if (res.status == '200') { //非新用户
                                console.log("走进来--非新用户")
                                wx.setStorage({
                                    key: 'user',
                                    data: res.data,
                                    success: function () {
                                        resolve(true)
                                    }
                                })
                            } else {
                                that.showRequestErrMsg(res)
                            }
                        })
                    }
                },
                fail: (err) => {
                    reject(err)
                }
            })
        })
    },
    /**
     * 显示请求异常信息
     * @param {object} res 响应数据
     */
    showRequestErrMsg(res) {
        this.showToast(res.msg ? res.msg : '您的网络开小差了~')
    },
    /**
     * 封装微信的轻提示
     * @param {string} title 标题
     * @param {string} icon 提示图标，默认为none，不显示图标
     * @param {number} duration 显示时长，单位毫秒，默认为1500毫秒
     */
    // 跳转
    tiao_Zhuan(url) {
        wx.navigateTo({
            url: url,
        })
    },
    showToast(title, icon = 'none', duration = 1500) {
        wx.showToast({
            title,
            icon,
            duration,
        })
    },
    /**
     * 显示登录页面
     * @param {string} content 提示信息
     */
    showLoginPage(content = null, back = null) {
        // 重定向页面，返回链接包含页面参数
        const pages = getCurrentPages()
        console.log(pages, "getCurrentPages")
        const currPage = pages[pages.length - 1] //当前页面
        // 当前是在登录页面，不再需要跳转
        console.log(currPage, "4218888")
        if (currPage.route === 'pages/login/index') {
            return
        }
        const backUrl = back ? back : this.getCurrentPageUrlWithArgs()

        // const backUrl = this.getCurrentPageUrlWithArgs() //来时页面
        console.log(backUrl, "laoide页面")
        const myUrl = config.myCenterUrl ? config.myCenterUrl : 'pages/mySelf/Index/index'
        if (currPage.route === myUrl) {
            console.log('1ff');
            wx.navigateTo({
                url: '/pages/login/index',
                success: (res) => {
                    if (content) {
                        this.showToast(content, 'none', 2500)
                    }
                }
            })
        } else {
            console.log('2ab');
            wx.redirectTo({
                url: '/pages/login/index?backUrl=' + encodeURIComponent(backUrl),
                success: (res) => {
                    if (content) {
                        this.showToast(content)
                    }
                }
            })
        }
    },
    /**
    * 显示倒计时
    * @param {number} ss 倒计时几分钟
    * @param {number} endTime 一般是后台返回的下单时间戳，
    */
    timersbsb(ss, endTime) {
        const nowDate = new Date().getTime(); //当前时间
        let lotteryTime = endTime + ss * 60 * 1000;
        let endSecs = parseInt((lotteryTime - nowDate) / 1000)
        this.timeOver(endSecs)
    },
    // 时间倒计时
    timeOver(endSecs) {
        const nowDate = new Date().getTime(); //当前时间
        var djsendtime = wx.getStorageSync('djsendtime'); //结束时间
        if (djsendtime != undefined && !isNaN(djsendtime) && djsendtime != '') {
            var locksecends = (djsendtime - nowDate) / 1000
            if (locksecends <= 0) {
                wx.removeStorageSync("djsendtime");
            } else {
                this.timeOvertwo(endSecs)
            }
        } else {
            this.timeOvertwo(endSecs)
        }

    },
    timeOvertwo(endSecs) {
        var djsendtime = wx.getStorageSync('djsendtime') //结束时间
        if (djsendtime == null || djsendtime == undefined || djsendtime == 'undefined' || djsendtime == 'null' || djsendtime == '') {
            var now = new Date().getTime(); //当前时间戳
            var endtime = endSecs * 1000 + now; //结束时间戳
            wx.setStorageSync('djsendtime', endtime); //将结束时间保存到cookie
        }
        // 倒计时
        let timd = setInterval(() => {
            endSecs--;
            console.log(endSecs)
            if (endSecs <= 0) {
                console.log("清除")
                wx.removeStorageSync("djsendtime");
                clearInterval(timd)
            } else {

            }
        }, 1000)

    },
    /**
     * 跳转到商品详情页面
     * @param {object} item 商品参数
     * @param {string} param 额外参数，格式为'&key=value'
     */
    gotoGoodsPage(item, param = '') {
        console.log(item)
        const idx = item.id
        const title = item.title ? item.title : ''
        const image = item.image
        const sellPoint = item.sellPoint ? item.sellPoint : ''
        var type = item.type ? item.type : ''
        wx.navigateTo({
            url: '/packageA/pages/Goods/GoodsDes/index?id=' + idx + '&name=' + title + '&image=' + image +
                '&sellPoint=' + sellPoint + param + '&type=' + type,
        })
    },
    /**
     * 跳转到店铺页面
     * @param {object} item 店铺参数
     * @param {string} param 额外参数，格式为'&key=value'
     */
    gotoStore(item, param = '') {
        const idx = item.storeId ? item.storeId : item.id // 兼容不同页面...
        const storeName = item.storeName ? item.storeName : item.name // 兼容不同页面...
        const storeImage = item.storeImage ? item.storeImage : ''
        const storeTypeName = item.storeTypeName ? item.storeTypeName : ''
        var storeType
        var type
        if (storeTypeName === '景区景点') {
            type = 1
        } else if (storeTypeName === '文体场馆') {
            type = 2
        } else {
            type = ''
        }

        if (storeTypeName === '景区景点' || storeTypeName === '运动健身' ||
            storeTypeName === '文博场馆' || storeTypeName === '文体场馆' || storeTypeName === '文化场馆') {
            wx.navigateTo({
                url: '/pages/ScenicArea/ScenicAreaMainPage/index?id=' + idx + '&moduleType=' + type +
                    '&storeTypeName=' + storeTypeName + '&storeType=' + storeType,
            })
            return
        } else if (storeTypeName === '酒店民宿') {
            wx.navigateTo({
                url: '/packageB/pages/hotel/hotel?id=' + idx + '&moduleType=1' +
                    '&storeTypeName=' + storeTypeName + '&storeType=' + storeType,
            })
        } else if (storeTypeName === '美食餐饮') {
            wx.navigateTo({
                url: '/packageA/pages/activety/activety?id=' + idx + '&moduleType=1' +
                    '&storeTypeName=' + storeTypeName + '&storeType=' + storeType,
            })
        } else {
            wx.navigateTo({
                url: '/packageA/pages/Goods/storePage/index?id=' + idx +
                    '&storeName=' + storeName +
                    '&storeImage=' + storeImage + param
            })
        }

    },
    gotoStoreid(item, param = '') {
        const idx = item.storeId ? item.storeId : item.id // 兼容不同页面...
        const storeImage = item.storeImage ? item.storeImage : ''
        const storeType = item.storeType ? item.storeType : ''
        if (storeType === '6') {
            type = 1
        } else if (storeType === '23') {
            type = 2
        } else {
            type = ''
        }
        if (storeType == '30' || storeType == '29' ||
            storeType == '6' || storeType == '5' ||
            storeType == '23') {
            wx.navigateTo({
                url: '/pages/ScenicArea/ScenicAreaMainPage/index?id=' + idx + '&moduleType=' + type +
                    '&storeTypeName=' + storeType,
            })
            return
        } else {
            wx.navigateTo({
                url: '/packageA/pages/Goods/storePage/index?id=' + idx +
                    '&storeName=' + storeType +
                    '&storeImage=' + storeImage + param
            })
        }

    },
    /**
     * 跳转到实名认证页面
     * @param {boolean} hasArgs 是否包含返回参数，包含返回参数，实名认证成功后会返回当前页面
     */
    toRealName(hasArgs = true) {
        const content = '您还未实名，请前往实名认证吧~'
        this.showAlertView(
            '温馨提示',
            content,
            (conform) => {
                if (conform) {
                    let backUrl = this.getCurrentPageUrlWithArgs()
                    console.log(backUrl, "backUrlbackUrlbackUrlbackUrl")
                    console.log(hasArgs, "hasArgshasArgshasArgshasArgshasArgs")
                    if (hasArgs) {
                        wx.redirectTo({
                            url: '/pages/realIdent/index?backUrl=' + encodeURIComponent(backUrl),
                        })
                    } else {
                        wx.navigateTo({
                            url: '/pages/realIdent/index',
                        })
                    }
                }
            },
            '去实名',
            '暂不实名')
    },
    /**
     * 获取当前页面Url和参数
     */
    getCurrentPageUrlWithArgs() {
        const pages = getCurrentPages()
        console.log(pages, "getCurrentPages")
        const currentPage = pages[pages.length - 1] //当前页面
        console.log(currentPage, "测试测试测试")
        const url = currentPage.route //从哪个页面跳过去的
        const options = currentPage.options
        let urlWithArgs = `/${url}?`

        for (let key in options) {
            const value = options[key]
            console.log(value)
            urlWithArgs += `${key}=${value}&` //字符拼接

        }
        urlWithArgs = urlWithArgs.substring(0, urlWithArgs.length - 1)
        return urlWithArgs
    },
    /**
     * 获取指定日期的周历
     * @param {number} date 时间戳
     */
    getWeekDate(date) {
        let now = new Date(date)
        let day = now.getDay()
        let weeks = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
        let week = weeks[day]
        return week
    },
    /**
     * 格式化日期
     * @param {string} fmt 格式化字符串
     * @param {number} adate 日期
     */
    dateFormat(fmt, adate = "", aa = null) {
        // yyyy-MM-dd HH:mm:ss
        let ret
        // console.log( adate)
        let date = new Date(adate)
        // console.log(date,"datedatedatedate")
        date.setDate(date.getDate() + aa);
        const opt = {
            "M+": (date.getMonth() + 1).toString(), // 月
            "d+": date.getDate().toString(), // 日
            "H+": date.getHours().toString(), // 时
            "m+": date.getMinutes().toString(), // 分
            "s+": date.getSeconds().toString() // 秒
        }
        if (/(y+)/.test(fmt)) fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
        for (let k in opt) {
            ret = new RegExp('(' + k + ')').exec(fmt)
            if (ret) {
                let value = (ret[1].length == 1) ? (opt[k]) : (('00' + opt[k]).substr(('' + opt[k]).length))
                fmt = fmt.replace(ret[1], value)
            }
        }
        return fmt
    },
    // 月日
    dateFormat(fmt, adate = "", aa = null) {
        // yyyy-MM-dd HH:mm:ss
        let ret
        // console.log( adate)
        let date = new Date(adate)
        // console.log(date,"datedatedatedate")
        date.setDate(date.getDate() + aa);
        const opt = {
            "M+": (date.getMonth() + 1).toString(), // 月
            "d+": date.getDate().toString(), // 日
            "H+": date.getHours().toString(), // 时
            "m+": date.getMinutes().toString(), // 分
            "s+": date.getSeconds().toString() // 秒
        }

        if (/(y+)/.test(fmt)) fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
        for (let k in opt) {
            ret = new RegExp('(' + k + ')').exec(fmt)
            if (ret) {
                let value = (ret[1].length == 1) ? (opt[k]) : (('00' + opt[k]).substr(('' + opt[k]).length))
                fmt = fmt.replace(ret[1], value)
            }
        }
        return fmt
    },
    // 时间戳返回周几
    parseTime(time, cFormat) {
        if (!time || arguments.length === 0) {
            return null
        }

        const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
        let date
        if (typeof time === 'object') {
            date = time
        } else {
            if (('' + time).length === 10) time = parseInt(time) * 1000
            if (typeof (time) === 'string') time = time.replace(/-/g, '/')
            date = new Date(time)
        }
        const formatObj = {
            y: date.getFullYear(),
            m: date.getMonth() + 1,
            d: date.getDate(),
            h: date.getHours(),
            i: date.getMinutes(),
            s: date.getSeconds(),
            a: date.getDay()
        }
        const timeStr = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
            let value = formatObj[key]
            if (key === 'a') return ['日', '一', '二', '三', '四', '五', '六'][value]
            if (result.length > 0 && value < 10) {
                value = '0' + value
            }
            return value || 0
        })
        return timeStr
    },

    /**
     * 获取本地用户信息
     * @param {function} complete 完成回调，获取成功或失败都会回调，第一个参数为获取状态，成功为true，失败为false，第二个参数为用户信息对象
     * @param {Boolean} needLogin 是否需要登录，默认为false
     * @description 示例，获取用户token和userId，未登录则跳转登录
     * getLocalUserInfo((success, data) => {
     *  if(success) {
     *    this.data.userId = data.user.id
     *    this.data.token = data.token
     *  }
     * }, true)
     */
    getLocalUserInfo(complete = () => { }, needLogin = false) {
        wx.getStorage({
            key: 'user',
            success: (res) => {
                complete(true, res.data)
            },
            fail: () => {
                complete(false, null)
                needLogin && this.showLoginPage()
            }
        })
    },
    /**
     * 判断当前字符串是否为空
     * @param {object} obj 需要判断的对象
     */
    isEmptyString(obj) {
        if (typeof obj == 'undefined' || obj === null || obj === '') {
            return true
        } else {
            return false
        }
    }
}